home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / Xpm / pixmap / PortEditorP.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  20KB  |  752 lines
  1. /*
  2.  * $Id: PortEditorP.c,v 1.2 1992/10/27 08:41:56 mallet Exp $
  3.  *
  4.  * Copyright 1992 Lionel Mallet
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appears in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of Lionel MALLET not be used in
  11.  * advertising or publicity pertaining to distribution of the software
  12.  * without specific, written prior permission.  Lionel MALLET makes no
  13.  * representations about the suitability of this software for any
  14.  * purpose.  It is provided "as is" without express or implied warranty.
  15.  *
  16.  * Lionel MALLET DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17.  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  18.  * FITNESS, IN NO EVENT SHALL Lionel MALLET BE LIABLE FOR ANY SPECIAL,
  19.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  20.  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  21.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  22.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  23.  *
  24.  *  This software is opened and free. Furthermore, everybody is kindly
  25.  * invited to participate to improve it for the benefit of all.
  26.  * Improvements can be new features, bugs fixes and porting issues
  27.  * resolution.
  28.  *
  29.  * Author:  Tim Wise - Scientific & Engineering Software (SES), Inc.
  30.  */
  31.  
  32. #include <string.h>
  33.  
  34. /*****************************************************************************/
  35. /*
  36.             Port List Routines 
  37.  
  38.     A list of ports is kept in the XpmExtension format which is an
  39.     array of strings, one for each port. Convert string format
  40.     to Port structure when needed.
  41. */
  42. /*****************************************************************************/
  43.  
  44. Boolean _PORTDEBUG = True;
  45.  
  46. #define XpmPortName    "Ports"
  47. #define UNKNOWN        -1
  48.  
  49. typedef char PortInfo[80];
  50.  
  51. typedef struct {
  52.     int  id;        /* unique number */
  53.     int  x;        /* location of port */
  54.     int  y;
  55.     char info[80];     /* port info: name, kind */
  56. } Port;
  57.  
  58.  
  59. /*--------------------------------------------------------------------------*/
  60. /*
  61.             N e w P o r t 
  62.  
  63.     Allocate a new port structure including a string for info.
  64.     Return a pointer to allocated structure.
  65. */
  66. /*--------------------------------------------------------------------------*/
  67. Port *NewPort()
  68. {
  69.     Port *p;
  70.  
  71.     p = (Port *) XtNew(Port);
  72.     if (p != NULL) {
  73.         p->id = UNKNOWN;
  74.         p->x  = UNKNOWN;
  75.         p->y  = UNKNOWN;
  76.         /* p->info = XtMalloc( sizeof(PortInfo) ) */
  77.         p->info[0] = '\0';
  78.     }
  79.     return  p;
  80. }
  81.  
  82.  
  83. /*--------------------------------------------------------------------------*/
  84. /*
  85.             S t r T o P o r t
  86.  
  87.     Convert a string to a port structure. Return a pointer to the
  88.      port structure. NOTE: Caller must free structure!!
  89. */
  90. /*--------------------------------------------------------------------------*/
  91. void StrToPort( str, p )
  92.     char *str;
  93.     Port *p;
  94. {
  95.     char *s, *t;
  96.  
  97.     if (str != NULL && p != NULL) {
  98.  
  99.         sscanf( str, "%d%d%d",&p->id, &p->x, &p->y );
  100.         p->info[0] = '\0';
  101.  
  102.     s = XtMalloc( strlen(str) + 1 );    
  103.         strcpy( s, str );
  104.         t = strtok( s, " ," );         /* first token  id */
  105.         t = strtok( NULL, " ," );    /* second token x  */
  106.         t = strtok( NULL, " ," );    /* third token  y  */
  107.  
  108.         if (t != NULL && t+strlen(t)+1 < s+strlen(str)) 
  109.             strcpy( p->info, t+strlen(t)+1 );/* stuff after tokens */
  110.         
  111.     }
  112. }
  113.  
  114.  
  115. /*--------------------------------------------------------------------------*/
  116. /*
  117.             P o r t T o S t r
  118.  
  119.     Convert a port structure to a string. Return pointer to string.
  120.     Caller must free string.
  121. */
  122. /*--------------------------------------------------------------------------*/
  123. char *PortToStr( p )
  124.     Port *p;
  125. {
  126.     char id_str[40];
  127.     char x_str[40];
  128.     char y_str[40];
  129.     char *str = NULL;
  130.  
  131.     if (p != NULL) {
  132.         sprintf( id_str, "%d\0", p->id );
  133.         sprintf( x_str,  "%d\0", p->x );
  134.         sprintf( y_str,  "%d\0", p->y );
  135.     str = XtMalloc( strlen(x_str) + strlen(y_str) + strlen(id_str)
  136.                         + strlen(p->info) + 4 );
  137.         str[0] = '\0';
  138.         strcat( str, id_str  );
  139.         strcat( str, " "     );
  140.         strcat( str, x_str   );
  141.         strcat( str, " "     );
  142.         strcat( str, y_str   );
  143.         strcat( str, " "     );
  144.         strcat( str, p->info );
  145.     }
  146.     return str;
  147. }
  148.  
  149.  
  150. /*--------------------------------------------------------------------------*/
  151. /*
  152.             U p d a t e P o r t 
  153.  
  154.     Replace string version of port i with info given in port structure.
  155. */
  156. /*--------------------------------------------------------------------------*/
  157. void UpdatePort( ports, i, p )
  158.     XpmExtension *ports;
  159.     int          i;
  160.     Port         *p;
  161. {
  162.     XtFree( ports->lines[i] );
  163.     ports->lines[i] = PortToStr( p );
  164. }
  165.  
  166.  
  167. /*--------------------------------------------------------------------------*/
  168. /*
  169.             F i n d P o r t 
  170.  
  171.     Search a list of ports and find the first at location (x,y).
  172.     If found, return index of port; otherwise return UNKNOWN.
  173. */
  174. /*--------------------------------------------------------------------------*/
  175. int FindPort( ports, at_x, at_y )
  176.     XpmExtension *ports;
  177.     Position     at_x;
  178.     Position     at_y;
  179. {
  180.     int   i;
  181.     int   x;
  182.     int   y;
  183.     Port  p;
  184.  
  185.     if (strcmp(ports->name, XpmPortName) == 0) {
  186.         for (i=0; i < ports->nlines ; i++) {
  187.             if ( StrToPort(ports->lines[i], &p) 
  188.                  && p.x == at_x && p.y == at_y ) {
  189.                 return i;
  190.             }
  191.         }
  192.     }
  193.     return UNKNOWN;
  194. }
  195.  
  196.  
  197. /*--------------------------------------------------------------------------*/
  198. /*
  199.              I s P o r t 
  200.  
  201.     See if a port exists at location (x,y). If so, return True and
  202.     set the index of the port extension and the index of the port. 
  203. */
  204. /*--------------------------------------------------------------------------*/
  205.  
  206. Boolean IsPort( w, x, y, ports, port_i )
  207.     widget       w;
  208.     Position     x;
  209.     Position     y;
  210.     XpmExtension **return_ports;    /* list of ports; can be NULL! */
  211.     int          *return_port_i;    /* index of port x,y; can be NULL! */
  212.  
  213. {
  214.     Boolean      result = False;
  215.     XpmExtension *ports;
  216.     int         i;
  217.     
  218.     if ( (ports=PWFindExtension( w, XpmPortName )) != NULL ) { 
  219.        if ( (j=FindPort(ports, x, y)) >= 0 ) {
  220.            result = True;
  221.        }
  222.     }
  223.     if ( return_port_i != NULL )
  224.         *return_port_i = port_i;
  225.  
  226.     if ( return_ports != NULL ) 
  227.         *return_ports = ports;
  228.  
  229.     else if ( ports != NULL )
  230.         XpmFreeExtension( ports );    /* free ports if caller */
  231.                                         /* doesn't want them    */
  232.     return result;
  233. }
  234.  
  235.  
  236. /*--------------------------------------------------------------------------*/
  237. /*
  238.             A d d P o r t
  239.  
  240.     Add a port to end of list. Return index of new port.
  241. */
  242. /*--------------------------------------------------------------------------*/
  243. int AddPort( ports, at_x, at_y )
  244.     XpmExtension *ports;
  245.     Position     at_x;
  246.     Position     at_y;
  247. {
  248.     Port *p;
  249.     char *port_str;
  250.     int  i = UNKNOWN;
  251.  
  252.     if ((p=NewPort()) != NULL) {
  253.  
  254.         p->x  = at_x;
  255.         p->y  = at_y;
  256.         p->id = 0;        /* mark as new port */
  257.  
  258.         if ( (port_str=PortToStr(p)) != NULL ) {
  259.  
  260.            i = ports->nlines;
  261.            ports->nlines++;
  262.  
  263.            if (ports->lines != NULL)
  264.                ports->lines = (char **) XtRealloc( 
  265.                                            ports->lines, 
  266.                                            ports->nlines * sizeof(char*) );
  267.            else 
  268.                ports->lines = (char **) XtNew( char** );
  269.  
  270.            ports->lines[i] = port_str;
  271.         }
  272.         XtFree(p);
  273.     }
  274.     return i;
  275. } 
  276.  
  277.  
  278.  
  279. /*--------------------------------------------------------------------------*/
  280. /*
  281.             D e l P o r t
  282.  
  283.     Delete port i. Shift array elements above i to the left.
  284. */
  285. /*--------------------------------------------------------------------------*/
  286. void DelPort( ports, i )
  287.     XpmExtension *ports;
  288.     int          i;
  289. {
  290.     char **s, **t, **last;
  291.  
  292.     XtFree( ports->lines[i] );
  293.  
  294.     last = ports->lines + ports->nlines;    /* last element */
  295.     ports->nlines--;
  296.  
  297.     /* shift left elements above deletion, if necessary */
  298.     if (ports->nlines > 0) 
  299.         for (t = ports->lines+i, s = ports->lines+i+1 ; s < last ; *t++ = *s++);
  300.     else {
  301.         XtFree( ports->lines );
  302.         ports->lines = NULL;
  303.     }
  304. } 
  305.  
  306.  
  307. /*--------------------------------------------------------------------------*/
  308. /*
  309.             T r a n s l a t e P o r t
  310.  
  311.     Add offsets dx and dy to location of port i.
  312. */
  313. /*--------------------------------------------------------------------------*/
  314. void TranslatePort( ports, port_i, dx, dy )
  315.     XpmExtension *ports;
  316.     int port_i;
  317.     int dx;
  318.     int dy;
  319. {
  320.     Port p;
  321.  
  322.     if ( StrToPort(ports->lines[port_i], &p) ) {
  323.         p.x += dx;
  324.         p.y += dy;
  325.         UpdatePort( ports, port_i, &p );
  326.     }
  327. }
  328.  
  329.  
  330. /*****************************************************************************/
  331. /*
  332.             Graphics Routines to draw  ports
  333. */
  334. /*****************************************************************************/
  335.  
  336.  
  337. /*--------------------------------------------------------------------------*/
  338. /*
  339.             P o r t S h a p e
  340.  
  341.     Return an array of points defining a port's shape.
  342. */
  343. /*--------------------------------------------------------------------------*/
  344. XPoint *PortShape(PW, x ,y)
  345.     PixmapWidget PW;
  346.     Position     x; 
  347.     Position     y;
  348. {
  349. #define NPortPoints 7
  350.     static XPoint points[NPortPoints];
  351.  
  352.     points[0].x = InWindowX(PW, x);
  353.     points[0].y = InWindowY(PW, y);
  354.     points[1].x = InWindowX(PW, x + 1.0/2);
  355.     points[1].y = InWindowY(PW, y + 1.0/2);
  356.     points[2].x = InWindowX(PW, x);
  357.     points[2].y = InWindowY(PW, y + 1);
  358.     points[3].x = InWindowX(PW, x + 1);
  359.     points[3].y = InWindowY(PW, y + 1);
  360.     points[4].x = InWindowX(PW, x + 1.0/2);
  361.     points[4].y = InWindowY(PW, y + 1.0/2);
  362.     points[5].x = InWindowX(PW, x + 1);
  363.     points[5].y = InWindowY(PW, y);
  364.     points[6].x = InWindowX(PW, x);
  365.     points[6].y = InWindowY(PW, y);
  366.  
  367.     return points;
  368. }
  369.  
  370.  
  371. /*--------------------------------------------------------------------------*/
  372. /*
  373.             D r a w P o r t
  374. */
  375. /*--------------------------------------------------------------------------*/
  376. #define DrawPort(w, x, y) \
  377.   XFillPolygon(XtDisplay(w), XtWindow(w), PW->pixmap.framing_gc,\
  378.                PortShape(w, x, y), NPortPoints, Convex, CoordModeOrigin)
  379.  
  380.  
  381. /*--------------------------------------------------------------------------*/
  382. /*
  383.             H i g h l i g h t P o r t
  384. */
  385. /*--------------------------------------------------------------------------*/
  386. #define HighlightPort(w, x, y)\
  387.   XFillPolygon(XtDisplay(w), XtWindow(w), PW->pixmap.highlighting_gc,\
  388.                PortShape(w, x, y), NPortPoints, Convex, CoordModeOrigin)
  389.  
  390.  
  391.  
  392. /*****************************************************************************/
  393. /*
  394.         Port Editor Interface Routines 
  395. */
  396. /*****************************************************************************/
  397.  
  398.  
  399. /*--------------------------------------------------------------------------*/
  400. /*
  401.             D r a w P o r t 
  402.  
  403.     Just draw a port a location (x,y) with given value (set, clear, 
  404.     invert, or highlight). 
  405. */
  406. /*--------------------------------------------------------------------------*/
  407. void DrawPort( w, x, y, value )
  408.     Widget   w;
  409.     Position x;
  410.     Position y;
  411.     int      value;
  412. {
  413.     if (value == Set)
  414.         DrawPort( w, x, y );
  415.  
  416.     else if (value == Clear || value == Invert)
  417.         DrawPort( w, x, y );
  418.  
  419.     else if (value == Highlight)
  420.         HighlightPort( w, x, y );
  421. }
  422.  
  423.  
  424. /*--------------------------------------------------------------------------*/
  425. /*
  426.             D r a w I f P o r t 
  427.  
  428.     Draw a port at location (x,y) if there is a port at that 
  429.     location. This routine is used to highlight a port that a
  430.     user is trying to pick.
  431. */
  432. /*--------------------------------------------------------------------------*/
  433. void DrawIfPort( w, x, y, value )
  434.     Widget   w;
  435.     Position x;
  436.     Position y;
  437.     int      value;
  438. {
  439.     if ( IsPort(w, x, y, NULL, NULL) )
  440.         DrawPort( w, x, y, value );
  441. } 
  442.  
  443.  
  444. /*--------------------------------------------------------------------------*/
  445. /*
  446.             S e t P o r t 
  447.  
  448.     Create and draw a port at (x,y) if there is not already a port
  449.     there. 
  450. */
  451. /*--------------------------------------------------------------------------*/
  452. void SetPort( w, x, y, value )
  453.     Widget   w;
  454.     Position x;
  455.     Position y;
  456.     int      value;
  457. {
  458.     int ext_i, port_i;
  459.  
  460.     if (_PORTDEBUG)
  461.         printf("SetPort : %d %d \n", x, y);
  462.  
  463.     if ( !IsPort(w, x, y, &ext_i, &port_i) ) {
  464.         if (ext_i == UNKNOWN) 
  465.             ext_i = AddExtension( &(PW->pixmap.extensions), 
  466.                                   &(PW->pixmap.nextensions), XpmPortName );
  467.  
  468.         AddPort(PW->pixmap.extensions + ext_i, x, y);
  469.         DrawPort(w, x, y, value);
  470.  
  471.     if (_PORTDEBUG)
  472.             PrintExtensions(PW->pixmap.extensions, PW->pixmap.nextensions);
  473.     }
  474. } 
  475.  
  476.  
  477. /*--------------------------------------------------------------------------*/
  478. /*
  479.             C l e a r P o r t 
  480.  
  481.     Delete the port at (x,y) from the port list and erase the port 
  482.     on the screen.
  483. */
  484. /*--------------------------------------------------------------------------*/
  485. void ClearPort(w, x, y, value)
  486.     Widget   w;
  487.     Position x;
  488.     Position y;
  489.     int      value;
  490. {
  491.     int ext_i, port_i;
  492.  
  493.     PixmapWidget PW = (PixmapWidget) w;
  494.  
  495.     if (_PORTDEBUG)
  496.         printf("PWClearPort : %d %d \n", x, y);
  497.  
  498.     if ( IsPort(PW, x, y, &ext_i, &port_i) ) { 
  499.         DelPort(PW->pixmap.extensions + ext_i, port_i);
  500.  
  501.         /* if no more data for this extension, delete it */
  502.         if (PW->pixmap.extensions[ext_i].nlines == 0)
  503.             DelExtension( &(PW->pixmap.extensions),
  504.                           &(PW->pixmap.nextensions), ext_i );
  505.  
  506.         DrawPort(w, x, y, value);
  507.     if (_PORTDEBUG)
  508.             PrintExtensions(PW->pixmap.extensions, PW->pixmap.nextensions);
  509.     }
  510. }
  511.  
  512.  
  513. /*--------------------------------------------------------------------------*/
  514. /*
  515.             D r a g P o r t 
  516.  
  517.     Draw a port while the user is dragging. Draw only if a port existed
  518.     at the starting location of the drag. 
  519. */
  520. /*--------------------------------------------------------------------------*/
  521.  
  522. static struct {
  523.     Boolean b;        /* Are we dragging? */
  524.     XPoint  from;    /* starting point of drag */
  525. } dragging = { False };
  526.  
  527. void DragPort(w, x, y, value)
  528.     Widget   w;
  529.     Position x;
  530.     Position y;
  531.     int      value;
  532. {
  533.     PixmapWidget PW = (PixmapWidget) w;
  534.  
  535.     /* if beginning of drag, ... */
  536.     if (dragging.b == False) {
  537.         dragging.b = True;
  538.     dragging.from.x = x;
  539.     dragging.from.y = y;
  540.     }
  541.  
  542.     if (IsPort(PW, dragging.from.x, dragging.from.y, NULL, NULL)) {
  543.         DrawPort( w, dragging.from.x, dragging.from.y, value );/* erase */
  544.         DrawPort( w, x, y, value );/* draw */
  545.     }
  546. }
  547.  
  548. /*--------------------------------------------------------------------------*/
  549. /*
  550.             M o v e P o r t 
  551.  
  552.     Move a port from one location to another after user has completed
  553.     dragging.
  554. */
  555. /*--------------------------------------------------------------------------*/
  556. void MovePort( w, new_x, new_y, value )
  557.     Widget   w;
  558.     Position new_x;
  559.     Position new_y;
  560.     int      value;
  561. {
  562.     XpmExtension *ports;
  563.     Port         p;
  564.     int          i;
  565.  
  566.     if ( IsPort(w, dragging.from.x, dragging.from.y, &ports, &i) && 
  567.         !IsPort(PW, new_x, new_y, NULL, NULL)  ) {
  568.  
  569.         DrawPort( w, dragging.from.x, dragging.from.y, value );/* erase old */
  570.         DrawPort( w, new_x, new_y, value );                     /* draw  new */
  571.  
  572.         TranslatePort( ports, i, 
  573.                        new_x - dragging.from.x, 
  574.                        new_y - dragging.from.y  );
  575.  
  576.         PWUpdateExtension( w, ports );
  577.     XpmFreeExtensions( ports );
  578.     if (_PORTDEBUG)
  579.             PrintPorts( ports );
  580.     }
  581.     dragging.b = False;
  582. }
  583.  
  584.  
  585. /*--------------------------------------------------------------------------*/
  586. /*
  587.             P o r t I n f o
  588.  
  589.     Allow the user to edit the port information for the port at (x,y).
  590. */
  591. /*--------------------------------------------------------------------------*/
  592.  
  593. #include "Dialog.h"
  594. extern Dialog input_dialog;
  595.  
  596. void PortInfo( w, x, y, value )
  597.     Widget   w;
  598.     Position x;
  599.     Position y;
  600.     int      value;
  601. {
  602.     XpmExtension *ports;
  603.     Port         p;
  604.     int          i;
  605.     char         *newInfo;
  606.  
  607.     if ( IsPort(w, x, y, &ports, &i) ) { 
  608.         StrToPort( ports->lines[i], &p );
  609.         if ( PopupDialog( input_dialog, 
  610.                           "Port Info: <name> <kind>",
  611.                            p.info, &newInfo,
  612.                           XtGrabExclusive) == Okay ) {
  613.         strcpy( p.info, newInfo );
  614.             UpdatePort( ports, i, &p ); 
  615.         }
  616.         PWUpdateExtension( w, ports );
  617.     XpmFreeExtensions( ports );
  618.     if (_PORTDEBUG)
  619.             PrintPorts( ports );
  620.     }
  621. }
  622.  
  623.  
  624. /*--------------------------------------------------------------------------*/
  625. /*
  626.             R e d r a w P o r t s
  627.  
  628.     Redraw all ports of PixmapWidget.
  629. */
  630. /*--------------------------------------------------------------------------*/
  631.  
  632. void RedrawPorts( w )
  633.     Widget w;
  634. {
  635.     XpmExtension *ports;
  636.     Port         p;
  637.     int          i;
  638.  
  639.     if ( (ports=PWFindExtension( w, XpmPortName )) != NULL ) { 
  640.         for ( i=0; i < ports->nlines; i++ ) { 
  641.             StrToPort( ports->lines[i], &p );
  642.             DrawPort( w, p.x, p.y ); 
  643.         }
  644.     }
  645. }
  646.  
  647.  
  648. /*--------------------------------------------------------------------------*/
  649. /*
  650.             T r a n s l a t e P o r t s 
  651.  
  652.     For all ports in PixmapWidget, add dx,dy to the ports location.
  653. */
  654. /*--------------------------------------------------------------------------*/
  655.  
  656. void TranslatePorts( PW, dx, dy )
  657.     PixmapWidget PW;
  658.     int dx;
  659.     int dy;
  660. {
  661.     XpmExtension *ports;
  662.     Port         p;
  663.     int          i;
  664.  
  665.     if ( (ports=PWFindExtension( w, XpmPortName )) != NULL ) { 
  666.         for ( i=0; i < ports->nlines; i++ ) { 
  667.             StrToPort( ports->lines[i], &p );
  668.  
  669.             DrawPort( w, p.x, p.y );            /* erase old */
  670.             PWTranslatePoint( w, &p.x, &p.y, dx, dy ); 
  671.             DrawPort( w, p.x, p.y );            /* draw new */
  672.  
  673.         UpdatePort( ports, i, &p );
  674.         }
  675.         PWUpdateExtension( w, ports );
  676.     XpmFreeExtensions( ports );
  677.     if (_PORTDEBUG)
  678.             PrintPorts( ports );
  679.     }
  680.  
  681. }
  682.  
  683.  
  684. /*--------------------------------------------------------------------------*/
  685. /*
  686.             F l i p P o r t s 
  687.  
  688.     Flip all ports of a PixmapWidget either horiziontally or vertically.
  689. */
  690. /*--------------------------------------------------------------------------*/
  691.  
  692. void FlipPorts( w, axis  )
  693.     widget         w;
  694.     enum FlipAxis    axis;
  695. {
  696.     XpmExtension *ports;
  697.     Port         p;
  698.     int          i;
  699.  
  700.     if ( (ports=PWFindExtension( w, XpmPortName )) != NULL ) { 
  701.         for ( i=0; i < ports->nlines; i++ ) { 
  702.             StrToPort( ports->lines[i], &p );
  703.  
  704.             DrawPort( w, p.x, p.y );            /* erase old */
  705.             PWFlipPoint( w, &p.x, &p.y, axis ); 
  706.             DrawPort( w, p.x, p.y );            /* draw new */
  707.  
  708.         UpdatePort( ports, i, &p );
  709.         }
  710.         PWUpdateExtension( w, ports );
  711.     XpmFreeExtensions( ports );
  712.     if (_PORTDEBUG)
  713.             PrintPorts( ports );
  714.     }
  715. }
  716.  
  717.  
  718. /*--------------------------------------------------------------------------*/
  719. /*
  720.             R o t a t e P o r t s 
  721.  
  722.     Flip all ports of a PixmapWidget either left or right 90 degrees.
  723. */
  724. /*--------------------------------------------------------------------------*/
  725.  
  726. void RotatePorts( w, direction )
  727.     widget            w;
  728.     enum RotateDirection    direction;
  729. {
  730.     XpmExtension *ports;
  731.     Port         p;
  732.     int          i;
  733.  
  734.     if ( (ports=PWFindExtension( w, XpmPortName )) != NULL ) { 
  735.         for ( i=0; i < ports->nlines; i++ ) { 
  736.             StrToPort( ports->lines[i], &p );
  737.  
  738.             DrawPort( w, p.x, p.y );            /* erase old */
  739.             PWRotatePoint( w, &p.x, &p.y, direction ); 
  740.             DrawPort( w, p.x, p.y );            /* draw new */
  741.  
  742.         UpdatePort( ports, i, &p );
  743.         }
  744.         PWUpdateExtension( w, ports );
  745.     XpmFreeExtensions( ports );
  746.     if (_PORTDEBUG)
  747.             PrintPorts( ports );
  748.     }
  749. }
  750.  
  751.  
  752.